#include "SawedOffShotgunRacruvido.h"
#include <GL/glu.h>
#include "gllib/Objects.h"
#include "src/mathlib/Matrix4.h"
#include <cmath>

// Variaveis globais:
double cano_raio = 0.18;
double cano_comprimento = 2.0;
double cano_precisao = 10.0;
double cano_traseira_escala = 0.6;
double cano_buraco_comprimento = 0.002;

double divisoria_lado = cano_raio;
double divisoria_largura = 0.9;
double divisoria_altura = 1.4;
double divisoria_comprimento = 10.85;

double suporte_lado = cano_raio;
double suporte_largura = 2.5;
double suporte_comprimento = 7.5;

double cao_lado = 0.05;
double cao_altura = 4.0;
double cao_recuo = -0.09;

double gatilho_raio_interno = 0.04;
double gatilho_raio_externo = 0.2;
double gatilho_rebaixamento = -0.26;
double gatilho_click_raio = 0.04;

double cabo_raio = 0.16;
double cabo_comprimento = 1.4;
double cabo_precisao = 10.0;

void draw_cano(float posicaoX)
{
    // Canos em si:
    glPushMatrix();
        // Deitar o cano:
        rotationMatrix(rad(90),Vector3(1.0,0.0,0.0)).applyGL();
        // Alinhar o cano:
        translationMatrix(Vector3(0.0,(cano_comprimento/2.0),0.0)).applyGL();
        // Posição do cano no eixo-X:
        translationMatrix(Vector3(posicaoX,0.0,0.0)).applyGL();
        // Primitiva:
        gllibCylinder(cano_raio,cano_comprimento,cano_precisao);
    glPopMatrix();
    // Parte traseira:
    glPushMatrix();
        scaleMatrix(1.0,1.0,cano_traseira_escala).applyGL();
        translationMatrix(Vector3(posicaoX,0.0,0.0)).applyGL();
        gllibSphere(cano_raio,cano_precisao);
    glPopMatrix();
    // "Buracos" nos canos:
    glColor3f(0.0, 0.0, 0.0);
    glPushMatrix();
        translationMatrix(Vector3(posicaoX,0.0,cano_comprimento+cano_buraco_comprimento)).applyGL();
        rotationMatrix(rad(90),Vector3(1.0,0.0,0.0)).applyGL();
        gllibCylinder((0.8)*cano_raio,cano_buraco_comprimento,cano_precisao);
    glPopMatrix();
}

void draw_cao(double posicaoX)
{
    glPushMatrix();
        shearMatrix(70).applyGL();
        scaleMatrix(1.0,cao_altura,1.0).applyGL();
        translationMatrix(Vector3(posicaoX,(cao_lado/2.0),cao_recuo)).applyGL();
        gllibCube(cao_lado);
    glPopMatrix();
}

void draw_divisoria(void)
{
    glPushMatrix();
        // Subir divisoria:
        translationMatrix(Vector3(0.0,0.05,0.0)).applyGL();
        // Esticar divisoria:
        scaleMatrix(divisoria_largura,divisoria_altura,divisoria_comprimento).applyGL();
        // Alinhar divisoria:
        translationMatrix(Vector3(0.0,0.0,(divisoria_lado/2.0))).applyGL();
        // Primitiva:
        gllibCube(divisoria_lado);
    glPopMatrix();
}

void draw_suporte(void)
{
    glPushMatrix();
        // Esticar suporte:
        scaleMatrix(suporte_largura,1.0,suporte_comprimento).applyGL();
        // Ajustar posicao do suporte:
        translationMatrix(Vector3(0.0,-suporte_lado,(suporte_lado/2.0))).applyGL();
        // Primitiva:
        gllibCube(suporte_lado);
    glPopMatrix();
}

void draw_cabo(void)
{
    glPushMatrix();
        // Colocar o cabo no local:
        translationMatrix(Vector3(0.0,-0.27,-0.17)).applyGL();
        // Rodar o cabo:
        rotationMatrix(rad(85),Vector3(1.0,0.0,0.0)).applyGL();
        // Escalar e cisalhar:
        shearMatrix(80).applyGL();
        scaleMatrix(1.0,1.0,2.0).applyGL();
        // Primitiva:
        gllibCone(cabo_raio,cabo_comprimento,cabo_precisao);
    glPopMatrix();
}

void draw_gatilho(void)
{
    // Proteção do gatilho:
    glColor3f(0.52, 0.37, 0.26);
    glPushMatrix();
        translationMatrix(Vector3(0.0,gatilho_rebaixamento,0.3)).applyGL();
        rotationMatrix(rad(30),Vector3(1.0,0.0,0.0)).applyGL();
        rotationMatrix(rad(90),Vector3(0.0,0.0,1.0)).applyGL();
        gllibTorus(gatilho_raio_interno,gatilho_raio_externo,2.0,3.0);
    glPopMatrix();
    // Gatilho em si:
    glColor3f(0.9,0.3,0.3);
    glPushMatrix();
        translationMatrix(Vector3(0.0,-0.33,0.3)).applyGL();
        shearMatrix(70).applyGL();
        scaleMatrix(1.0,3.0,1.0).applyGL();
        gllibCube(gatilho_click_raio);
    glPopMatrix();
}

void SawedOffShotgunRacruvido::draw()
{
    /// *** Eixo Y auxiliar ***
//    gllibEixoY();

    /// *** Canos ***
    // Cano direito:
    glColor3f(0.5, 0.5, 0.5);
    draw_cano(cano_raio);
    // Cano esquerdo:
    glColor3f(0.5, 0.5, 0.5);
    draw_cano(-cano_raio);

    /// *** Divisoria entre os canos ***
    // Cor:
    glColor3f(0.35, 0.35, 0.35);
    // Desenhar:
    draw_divisoria();

    /// *** Caes ***
    // Cor:
    glColor3f(0.6, 0.6, 0.6);
    // Cao direito:
    draw_cao(cano_raio);
    // Cao esquerdo:
    draw_cao(-cano_raio);

    /// *** Suporte (parte de baixo) ***
    // Cor (cor de madeira, espero eu...):
    glColor3f(0.5, 0.50, 0.39);
    // Desenhar:
    draw_suporte();

    /// *** Gatilho ***
    draw_gatilho();

    /// *** Cabo ***
    // Cor:
    glColor3f(0.52, 0.37, 0.26);
    // Desenhar:
    draw_cabo();
}
